home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 001 / pibt3sp4.arc / SENDASCI.PAS < prev    next >
Encoding:
Pascal/Delphi Source File  |  1985-09-11  |  8.7 KB  |  251 lines
  1. (*----------------------------------------------------------------------*)
  2. (*                Send_Ascii_File --- Upload ASCII file                 *)
  3. (*----------------------------------------------------------------------*)
  4.  
  5. OVERLAY PROCEDURE Send_Ascii_File;
  6.  
  7. (*----------------------------------------------------------------------*)
  8. (*                                                                      *)
  9. (*     Procedure:  Send_Ascii_File                                      *)
  10. (*                                                                      *)
  11. (*     Purpose:    Uploads ASCII file to remote host                    *)
  12. (*                                                                      *)
  13. (*     Calling Sequence:                                                *)
  14. (*                                                                      *)
  15. (*        Send_Ascii_File;                                              *)
  16. (*                                                                      *)
  17. (*     Calls:   KeyPressed                                              *)
  18. (*              Async_Send_String                                       *)
  19. (*              Async_Receive                                           *)
  20. (*                                                                      *)
  21. (*----------------------------------------------------------------------*)
  22.  
  23. CONST
  24.    Pacing_Delay = 0.35             (* Approx. time added per line for pacing *);
  25.    Modem_Fudge  = 0.85             (* Approx. fudge factor for timing        *);
  26.  
  27. VAR
  28.    Ch           : CHAR;
  29.    Fin          : BOOLEAN;
  30.    TextLine     : AnyStr;
  31.    Esc_Found    : BOOLEAN;
  32.    B            : BOOLEAN;
  33.    Pace_Found   : BOOLEAN;
  34.    Line_Count   : REAL;
  35.    Byte_Count   : REAL;
  36.    Time_To_Send : REAL;
  37.    Length_Line  : REAL;
  38.    R_Baud_Rate  : REAL;
  39.    AFile_Byte   : FILE OF BYTE;
  40.    Start_Time   : REAL;
  41.    TLine_Delay  : REAL;
  42.    Pacing       : BOOLEAN;
  43.    I            : INTEGER;
  44.  
  45. (*----------------------------------------------------------------------*)
  46. (*     Update_Ascii_Send_Display --- Update display of Ascii upload     *)
  47. (*----------------------------------------------------------------------*)
  48.  
  49. PROCEDURE Update_Ascii_Send_Display;
  50.  
  51. BEGIN (* Update_Ascii_Send_Display *)
  52.  
  53.    GoToXY( 26 , 5 );
  54.    WRITE( Line_Count:8:0 );
  55.    GoToXY( 26 , 6 );
  56.    WRITE( Byte_Count:8:0 );
  57.    GoToXY( 26 , 7 );
  58.    WRITE( TimeString( Time_To_Send ) );
  59.  
  60. END   (* Update_Ascii_Send_Display *);
  61.  
  62. (*----------------------------------------------------------------------*)
  63.  
  64. BEGIN (* Send_Ascii_File *)
  65.  
  66.                                    (* Open display window for transfer  *)
  67.    Save_Screen( Saved_Screen );
  68.  
  69.    Draw_Menu_Frame( 15, 10, 78, 21, Menu_Frame_Color,
  70.                     Menu_Text_Color,
  71.                     'Send file ' + FileName + ' using ASCII' );
  72.  
  73.                                    (* Figure transfer time *)
  74.    Window( 16, 11, 77, 20 );
  75.  
  76.    ASSIGN( Afile_Byte , FileName );
  77.    RESET ( Afile_Byte );
  78.  
  79.    R_Baud_Rate    := ( Baud_Rate * Modem_Fudge ) / 10.0;
  80.    Byte_Count     := LongFileSize( Afile_Byte );
  81.    Line_Count     := 0;
  82.  
  83.    CLOSE( Afile_Byte );
  84.                                    (* Read file and find # of lines *)
  85.    WRITELN;
  86.    WRITELN(' Scanning ',FileName,' for line count');
  87.  
  88.    ASSIGN( Afile , FileName );
  89.    RESET ( Afile );
  90.  
  91.    REPEAT
  92.       READLN( Afile );
  93.       Line_Count := Line_Count + 1;
  94.    UNTIL( EOF( Afile ) );
  95.  
  96.    RESET( Afile );
  97.                                    (* Figure approximate transfer time *)
  98.  
  99.    Time_To_Send   := Byte_Count / R_Baud_Rate + Char_Delay * Byte_Count +
  100.                      Line_Delay * Line_Count;
  101.  
  102.    TLine_Delay    := Line_Delay;
  103.  
  104.    IF ( Char_Delay   = 0 ) AND
  105.       ( Line_Delay   = 0 ) AND
  106.       ( Pacing_Char <> CHR( NUL ) ) THEN
  107.       BEGIN
  108.          Time_To_Send := Time_To_Send + Line_Count * Pacing_Delay;
  109.          TLine_Delay  := TLine_Delay  + Pacing_Delay;
  110.       END;
  111.  
  112.    Clear_Window;
  113.  
  114.    WRITELN(' Characters to send    : ', Byte_Count:8:0 );
  115.    WRITELN(' Lines to send         : ', Line_Count:8:0 );
  116.    WRITELN(' Approx. transfer time : ', TimeString( Time_To_Send ) );
  117.    WRITELN(' ');
  118.    WRITELN(' Sending line          : ');
  119.    WRITELN(' Bytes left to send    : ');
  120.    WRITELN(' Approx. time left     : ', TimeString( Time_To_Send ) );
  121.  
  122.                                    (* Reset line count                 *)
  123.    Line_Count     := 0;
  124.                                    (* FIN is true when upload complete *)
  125.    Fin            := FALSE;
  126.                                    (* Remember starting time           *)
  127.    Start_Time     := TimeOfDay;
  128.                                    (* Flag if pacing char found:       *)
  129.                                    (* assumed TRUE to start things off *)
  130.    Pace_Found     := TRUE;
  131.    Pacing         := FALSE;
  132.                                    (* Loop over lines in file          *)
  133.    REPEAT
  134.                                    (* Look if carrier dropped          *)
  135.  
  136.       Fin := Fin OR Async_Carrier_Drop;
  137.  
  138.                                    (* Check buffer status, allow drain if *)
  139.                                    (* too full.                           *)
  140.       Async_Buffer_Full;
  141.                                    (* READ a line from the file to upload *)
  142.       READLN( AFile , TextLine );
  143.       TextLine    := TextLine + CR_LF_String;
  144.       Length_Line := LENGTH( TextLine ) + 1;
  145.  
  146.                                    (* If pacing character specified, wait *)
  147.                                    (* for it to show up from com port     *)
  148.       Esc_Found  := FALSE;
  149.  
  150.       IF ( Pacing AND ( NOT Fin ) ) THEN
  151.          REPEAT
  152.             IF KeyPressed THEN
  153.                BEGIN
  154.                   READ( Kbd, Ch );
  155.                   IF Ch = CHR( ESC ) THEN
  156.                      Esc_Found := TRUE
  157.                   ELSE
  158.                      Async_Send( Ch );
  159.                END;
  160.             IF Async_Buffer_Check THEN
  161.                BEGIN
  162.                   B := Async_Receive( Ch );
  163.                   Pace_Found := ( Ch = Pacing_Char );
  164.                END;
  165.          UNTIL ( Pace_Found OR Esc_Found )
  166.       ELSE
  167.          REPEAT
  168.             IF KeyPressed THEN
  169.                BEGIN
  170.                   READ( Kbd, Ch );
  171.                   IF Ch = CHR( ESC ) THEN
  172.                      Esc_Found := TRUE
  173.                   ELSE
  174.                      Async_Send( Ch );
  175.                END;
  176.             IF Async_Buffer_Check THEN
  177.                B := Async_Receive( Ch );
  178.          UNTIL ( Pace_Found OR Esc_Found );
  179.  
  180.                                    (* Check if Alt-S hit again --  *)
  181.                                    (* end transfer if so.          *)
  182.  
  183.       IF ( Esc_Found AND KeyPressed ) THEN
  184.          BEGIN
  185.             READ( Kbd , Ch );
  186.             IF ORD( Ch ) = Alt_S THEN
  187.                Fin := TRUE
  188.             ELSE
  189.                BEGIN
  190.                   Async_Send( CHR( ESC ) );
  191.                   Async_Send( Ch );
  192.                END;
  193.          END
  194.       ELSE
  195.          WHILE KeyPressed DO
  196.             BEGIN
  197.                READ( Kbd, Ch );
  198.                Async_Send( Ch );
  199.             END;
  200.                                    (* Send the next line to the host *)
  201.  
  202.       IF ( NOT Fin ) THEN
  203.          Async_Send_String_With_Delays( TextLine, Char_Delay, Line_Delay );
  204.  
  205.                                    (* Update status display *)
  206.  
  207.       Line_Count   := Line_Count   + 1;
  208.  
  209.       Byte_Count   := Byte_Count   - Length_Line;
  210.       IF Byte_Count < 0.0 THEN
  211.          Byte_Count := 0.0;
  212.  
  213.       Time_To_Send := Time_To_Send - ( Length_Line / R_Baud_Rate )
  214.                                    - ( Length_Line * Char_Delay  )
  215.                                    - TLine_Delay ;
  216.       IF Time_To_Send <= 0.0 THEN
  217.          Time_To_Send := 0.0;
  218.  
  219.       Update_Ascii_Send_Display;
  220.                                    (* Ensure pacing if needed after *)
  221.                                    (* first block                   *)
  222.  
  223.       Pacing := Pacing_Char <> CHR( NUL );
  224.  
  225.    UNTIL ( Fin OR EOF( AFile ) );
  226.  
  227.                                    (* Wait for buffer to drain *)
  228.    Async_Purge_Buffer;
  229.  
  230.    GoToXY( 1 , 9 );
  231.  
  232.    IF ( NOT Fin ) THEN
  233.       BEGIN
  234.          Writelne(' Finished sending Ascii file ' + FileName , TRUE );
  235.          GoToXY( 1 , 10 );
  236.          WRITE (' Actual transfer time was ',
  237.                 TimeString( TimeDiff( Start_Time, TimeOfDay ) ) );
  238.       END
  239.    ELSE
  240.       Writelne(' Transfer cancelled' , TRUE );
  241.  
  242.    DELAY ( Two_Second_Delay );
  243.  
  244.    CLOSE( AFile );
  245.                                    (* Remove this window            *)
  246.    Restore_Screen( Saved_Screen );
  247.  
  248.    Reset_Global_Colors;
  249.  
  250. END   (* Send_Ascii_File *);
  251.